// 获取用户统计数据
function fetchUserStats() {
    // 获取普通用户数据
    axios.get('/new/countuser', {
        headers: {'User-Type': 'Admin'}
    })
        .then(response => {
            const normalUsers = response.data;
            document.getElementById('normalUserCount').textContent = normalUsers.length;
            displayUserList(normalUsers, 'normalUserList', false);
        })
        .catch(err => console.error('获取普通用户数据失败:', err));
}

// 在页面加载时调用 fetchUserStats()
document.addEventListener('DOMContentLoaded', function () {
});

//权限
function getParameterByName(name, url = window.location.href) {
    name = name.replace(/[\[\]]/g, '\\$&');
    const regex = new RegExp(`[?&]${name}(=([^&#]*)|&|#|$)`);
    const results = regex.exec(url);
    if (!results) return null;
    if (!results[2]) return '';
    return decodeURIComponent(results[2].replace(/\+/g, ' '));
}

const uroot = getParameterByName('uroot');
const root = parseInt(uroot, 10);

var uid = getParameterByName('uid');
const id = parseInt(uid, 10);

var name = getParameterByName('uname');
// 检查用户权限
if (uroot === null) {
    alert('身份认证失败，请重新登录');
    window.location.href = 'login.html';
}
document.addEventListener('DOMContentLoaded', function () {
    fetchUserStats();

    if (uroot != 8) {
        const ftypeElement = document.getElementById('ftype');
        if (ftypeElement) {
            ftypeElement.style.display = 'none';
        }
    }


    if (![4, 5, 6, 7, 8].includes(root)) {
        const ftypeElement = document.getElementById('ftype1');
        if (ftypeElement) {
            ftypeElement.style.display = 'none';
        }
    }


    const freezeCheckbox = document.getElementById('404');
    const otherCheckboxes = [
        document.getElementById('permAddSelect'),
        document.getElementById('permDataSelect'),
        document.getElementById('permManageSelect'),
        document.getElementById('permSuperSelect')
    ];

    if (freezeCheckbox) {
        freezeCheckbox.addEventListener('change', function () {
            if (this.checked) {
                // 如果冻结账号被选中，禁用其他多选框
                otherCheckboxes.forEach(checkbox => {
                    checkbox.disabled = true;
                    checkbox.checked = false; // 可选：清除其他多选框的选中状态
                });
            } else {
                // 如果冻结账号被取消选中，启用其他多选框
                otherCheckboxes.forEach(checkbox => {
                    checkbox.disabled = false;
                });
            }
        });
    }
});


// 显示用户列表
function displayUserList(users, containerId, isAdmin) {
    const container = document.getElementById(containerId);
    let html = `
        <table class="user-table">
            <thead>
                <tr>
    `;
    if ([4, 8].includes(root)) {
        html += '<th>用户ID</th>';
    }
    html += `  
                    <th>用户名</th>
    `;
    if ([8].includes(root)) {
        html += '<th>密码</th>';
    }
    if ([4, 8].includes(root)) {
        html += '<th>权限</th>';
    }

    // 注册时间列始终显示
    html += `<th>注册时间</th>`;

    // 操作列仅在 uroot=8 时显示
    if ([4, 8].includes(root)) {
        html += `<th>操作</th>`;
    }

    html += `
                </tr>
            </thead>
            <tbody>
    `;

    // 筛选用户列表逻辑保持不变
    const filteredUsers = users.filter(user => {
        if (root === 8) return true;
        return user.uroot !== 8;
    });

    filteredUsers.forEach(user => {
        // 解析用户权限逻辑保持不变
        let permission = '';
        if (user.uroot === 2) permission = '数据处理';
        else if (user.uroot === 4) permission = '用户管理';
        else if (user.uroot === 8) permission = '高级管理员';
        else if (user.uroot === 0) permission = '账号已冻结';

        html += `<tr>`;

        // 用户ID列
        if ([4, 8].includes(root)) {
            html += `<td>${user.uid}</td>`;
        }

        // 用户名列
        html += `<td>${user.uname}</td>`;

        // 密码列
        if ([8].includes(root)) {
            html += `<td>${user.upass}</td>`;
        }

        // 权限列
        if ([4, 8].includes(root)) {
            html += `<td><span class="status-badge ${getStatusClass(permission)}">${permission}</span></td>`;
        }

        // 注册时间列
        html += `<td>${user.time || '未知'}</td>`;

        // 操作列（仅在 uroot=8 时显示）
        if ([4, 8].includes(root)) {
            html += `
                <td>
                    <div class="dropdown">
                        <button class="dropbtn">操作</button>
                        <div class="dropdown-content">
                            <a href="#" onclick="openManageModal(${user.uid}, '${user.uname}', ${user.uroot})">权限管理</a>
                            <a href="#" onclick="openModifyModal(${user.uid}, '${user.uname}')">信息修改</a>
                            <a href="#" onclick="openDeleteModal(${user.uid}, '${user.uname}')">删除账号</a>
                        </div>
                    </div>
                </td>
            `;
        }

        html += `</tr>`; // 闭合行
    });

    html += `</tbody></table>`;
    container.innerHTML = html;
}

// 打开权限管理模态框
// 打开权限管理模态框（修改后）
function openManageModal(userId, userName, userUroot) {
    // 保存当前操作用户信息到全局变量
    window.currentManagedUser = {
        uid: userId,
        uname: userName,
        uroot: userUroot
    };

    const modal = document.getElementById('manageModal');
    modal.style.display = 'block';

    // 重置所有单选按钮
    const radios = modal.querySelectorAll('input[type="radio"]');
    radios.forEach(radio => radio.checked = false);

    // 根据当前权限设置选中状态
    switch (userUroot) {
        case 2:
            document.getElementById('permDataSelect').checked = true;
            break;
        case 4:
            document.getElementById('permManageSelect').checked = true;
            break;
        case 8:
            document.getElementById('permSuperSelect').checked = true;
            break;
        case 0:
            document.getElementById('permFreezeSelect').checked = true;
            break;
    }
}

// 更新后的权限提交函数
function submitPermissionUpdate() {
    const modal = document.getElementById('manageModal');
    const selectedPerm = modal.querySelector('input[name="userPerm"]:checked');

    if (!selectedPerm) {
        alert('请选择新的权限等级！');
        return;
    }

    const newUroot = parseInt(selectedPerm.value, 10);

    // 从全局变量获取用户信息
    const {uid, uname} = window.currentManagedUser;

    // 调用更新函数
    updateUser(uid, uname, newUroot);
    closeManagelroot();
}

// 打开账号信息修改模态框
// 打开账号信息修改模态框
function openModifyModal(userId, userName) {
    document.getElementById('modifyModal').style.display = 'block';
    document.getElementById('modifyUserIdInput').value = userId;

    // 默认显示用户名修改输入框
    document.getElementById('newUnameContainer').style.display = 'block';
    document.getElementById('newUpassContainer').style.display = 'none';
    document.getElementById('updateUsername').checked = true;

    // 添加单选框的事件监听
    document.getElementById('updateUsername').onclick = function () {
        document.getElementById('newUnameContainer').style.display = 'block';
        document.getElementById('newUpassContainer').style.display = 'none';
    };

    document.getElementById('updatePassword').onclick = function () {
        document.getElementById('newUnameContainer').style.display = 'none';
        document.getElementById('newUpassContainer').style.display = 'block';
    };
}


// 修改后的 openDeleteModal 函数
// 打开删除账号模态框
function openDeleteModal(userId, userName) {
    // 保存当前操作用户信息到全局变量
    window.currentDeletedUser = {
        uid: userId,
        uname: userName
    };
    document.getElementById('deleteModal').style.display = 'block';
}


// 根据权限名称获取状态类名
function getStatusClass(permission) {
    const permissionMap = {
        '进入后台': 'status-admin',
        '数据处理': 'status-data',
        '用户管理': 'status-manage',
        '高级管理员': 'status-super',
        '账号已冻结': 'status-fourzerofour'
    };
    return permissionMap[permission] || 'status-normal';
}

// 新增模态框控制函数
// 切换注册用户模态框显示/隐藏
function toggleRegisterModal() {
    const registerModal = document.getElementById('registerModal');
    registerModal.style.display = registerModal.style.display === 'block' ? 'none' : 'block';
}


// 关闭模态框
function closeModal() {
    document.getElementById('registerModal').style.display = 'none';
    resetForm('registerModal');
}


function closeManagelroot() {
    document.getElementById('manageModal').style.display = 'none';
    resetForm('manageModal');
}

function closeModifyModal() {
    document.getElementById('modifyModal').style.display = 'none';
    resetForm('modifyModal');
}

// 关闭删除用户模态框
function closeDeleteModal() {
    document.getElementById('deleteModal').style.display = 'none';
    resetForm('deleteModal');
}

// 重置表单内容
function resetForm(modalId) {
    const modal = document.getElementById(modalId);
    const inputs = modal.querySelectorAll('input');
    inputs.forEach(input => {
        if (input.type === 'text' || input.type === 'password') {
            input.value = '';
        } else if (input.type === 'checkbox' || input.type === 'radio') {
            input.checked = false;
        }
    });
    const selects = modal.querySelectorAll('select');
    selects.forEach(select => {
        select.selectedIndex = 0;
    });
}

// 后台用户注册
// 后台用户注册
function zhuce() {
    const name = document.getElementById('unameInput').value;
    const pass = document.getElementById('upassInput').value;

    // 获取选中的权限值
    const selectedPerm = document.querySelector('input[name="userPerm"]:checked');
    let uroot = 0;
    if (selectedPerm) {
        uroot = parseInt(selectedPerm.value);
    }

    // 检查用户名和密码是否为空
    if (name === '' || pass === '') {
        alert('账号和密码不能为空！');
        return;
    }

    // 检查用户名和密码是否包含空格
    if (name.includes(' ') || pass.includes(' ')) {
        alert('账号和密码不能包含空格！');
        return;
    }

    // 检查用户名和密码是否为3-10位的字母或数字
    const pattern = /^[a-zA-Z0-9]{3,10}$/;
    if (!pattern.test(name) || !pattern.test(pass)) {
        alert('账号和密码必须为3-10位的字母或数字！');
        return;
    }

    $.ajax({
        type: 'POST',
        url: 'http://127.0.0.1:8080/new/zhuceuser',
        dataType: 'json',
        data: {uname: name, upass: pass, uroot: uroot},
        success: function (data) {
            if (data === 2) {
                alert('用户名已存在');
            } else {
                alert('注册成功');
                fetchUserStats();
                closeModifyModal();
            }
        },
        error: function () {
            alert('无法与数据库取得连接!!');
        }
    });
}

// 更新用户权限
// 更新后的 updateUser 函数权限检查逻辑
function updateUser(userId, userName, userRoot) {
    // 如果当前用户是超级管理员（uroot=8），直接允许修改，跳过权限检查
    if (root === 8) {
        proceedWithUpdate();
        return;
    }

    // 非超级管理员需要检查目标用户权限
    axios.get('/new/uroot', {
        params: {uid: userId},
        headers: {'User-Type': 'Admin'}
    })
        .then(response => {
            const targetUserUroot = response.data;
            if (targetUserUroot === 8) {
                alert('您没有权限修改高级管理员用户！');
                return;
            }
            proceedWithUpdate();
        })
        .catch(err => {
            console.error('获取目标用户 uroot 失败:', err);
            alert('获取用户权限失败！');
        });

    function proceedWithUpdate() {
        // 构造请求数据（保持原有逻辑）
        const requestData = {
            uid: userId,
            uname: userName,
            uroot: userRoot
        };

        $.ajax({
            type: 'POST',
            url: 'http://127.0.0.1:8080/new/updateUser',
            dataType: 'json',
            data: requestData,
            success: function (data) {
                if (data === 1) {
                    alert('用户权限更改成功！');
                    fetchUserStats();
                    closeModifyModal();
                } else {
                    alert('用户权限更改失败！');
                }
            },
            error: function () {
                alert('无法与服务器连接！');
            }
        });
    }
}

// 修改账号信息
// 修改账号信息
function modifyUser() {
    const userId = document.getElementById('modifyUserIdInput').value;
    const updateType = document.querySelector('input[name="updateType"]:checked');
    let newUname = '';
    let newUpass = '';

    // 检查是否选择了修改类型
    if (!updateType) {
        alert('请选择修改类型（用户名或密码）！');
        return;
    }

    // 根据修改类型获取新值
    if (updateType.value === 'username') {
        newUname = document.getElementById('newUnameInput').value;
    } else if (updateType.value === 'password') {
        newUpass = document.getElementById('newUpassInput').value;
    }

    // 检查用户ID是否为空
    if (userId === '') {
        alert('请输入用户ID！');
        return;
    }

    // 检查用户ID是否包含空格
    if (userId.includes(' ')) {
        alert('请输入正确的用户ID');
        return;
    }

    // 如果当前用户的 uroot 不是 8，检查目标用户的 uroot
    if (root !== 8) {
        // 调用后端接口获取目标用户的 uroot
        axios.get('/new/uroot', {
            params: {
                uid: userId
            },
            headers: {'User-Type': 'Admin'}
        })
            .then(response => {
                const targetUserUroot = response.data;
                if (targetUserUroot === 8) {
                    alert('您没有权限修改高级管理员用户！');
                    return;
                }
                // 如果目标用户不是高级管理员，继续执行修改逻辑
                proceedWithModification();
            })
            .catch(err => {
                console.error('获取目标用户 uroot 失败:', err);
                alert('获取目标用户信息失败，请检查网络或接口地址！');
            });
    } else {
        // 如果当前用户是超级管理员，直接执行修改逻辑
        proceedWithModification();
    }

    function proceedWithModification() {
        // 检查修改类型是否为用户名
        if (updateType.value === 'username') {
            // 检查新用户名是否为空
            if (newUname === '') {
                alert('请输入新用户名！');
                return;
            }

            // 检查新用户名是否包含空格
            if (newUname.includes(' ')) {
                alert('新用户名不能包含空格！');
                return;
            }

            // 检查新用户名是否为3-10位的字母或数字
            const pattern = /^[a-zA-Z0-9]{3,10}$/;
            if (!pattern.test(newUname)) {
                alert('新用户名必须为3-10位的字母或数字！');
                return;
            }

            // 发送修改用户名的请求
            $.ajax({
                type: 'POST',
                url: 'http://127.0.0.1:8080/update/UserinfoName',
                dataType: 'json',
                data: {
                    uid: userId,
                    uname: newUname
                },
                success: function (data) {
                    if (data === 1) {
                        alert('用户名修改成功！');
                        fetchUserStats();
                        closeModifyModal();
                    } else {
                        alert('该用户名已存在');
                    }
                },
                error: function (xhr, textStatus, errorThrown) {
                    if (textStatus === 'error' && !xhr.responseText) {
                        alert('无法与服务器连接，请检查网络或接口地址！');
                    } else {
                        alert('用户名修改失败，请检查用户ID是否正确！');
                    }
                }
            });
        }

        // 检查修改类型是否为密码
        if (updateType.value === 'password') {
            // 检查新密码是否为空
            if (newUpass === '') {
                alert('请输入新密码！');
                return;
            }

            // 检查新密码是否包含空格
            if (newUpass.includes(' ')) {
                alert('新密码不能包含空格！');
                return;
            }

            // 检查新密码是否为3-10位的字母或数字
            const pattern = /^[a-zA-Z0-9]{3,10}$/;
            if (!pattern.test(newUpass)) {
                alert('新密码必须为3-10位的字母或数字！');
                return;
            }

            // 发送修改密码的请求
            $.ajax({
                type: 'POST',
                url: 'http://127.0.0.1:8080/update/UserinfoPass',
                dataType: 'json',
                data: {
                    uid: userId,
                    upass: newUpass
                },
                success: function (data) {
                    if (data === 1) {
                        alert('密码修改成功！');
                        fetchUserStats();
                        closeModifyModal();
                    } else {
                        alert('密码修改失败，请检查用户ID是否正确！');
                    }
                },
                error: function (xhr, textStatus, errorThrown) {
                    if (textStatus === 'error' && !xhr.responseText) {
                        alert('无法与服务器连接，请检查网络或接口地址！');
                    } else {
                        alert('密码修改失败，请检查用户ID是否正确！');
                    }
                }
            });
        }
    }
}

// 删除用户
// 删除用户
function deleteUser() {
    // 检查 window.currentDeletedUser 是否存在
    if (!window.currentDeletedUser) {
        alert('删除操作出错，请重新尝试！');
        return;
    }

    const {uid, uname} = window.currentDeletedUser;

    // 如果当前用户的 uroot 不是 8，检查目标用户的 uroot
    if (root !== 8) {
        // 调用后端接口获取目标用户的 uroot
        axios.get('/new/uroot', {
            params: {
                uid: uid
            },
            headers: {'User-Type': 'Admin'}
        })
            .then(response => {
                const targetUserUroot = response.data;
                if (targetUserUroot === 8) {
                    alert('您没有权限删除高级管理员用户！');
                    return;
                }
                // 如果目标用户不是高级管理员，继续执行删除逻辑
                proceedWithDeletion();
            })
            .catch(err => {
                console.error('获取目标用户 uroot 失败:', err);
                alert('获取目标用户信息失败，请检查网络或接口地址！');
            });
    } else {
        // 如果当前用户是超级管理员，直接执行删除逻辑
        proceedWithDeletion();
    }

    function proceedWithDeletion() {
        // 确认是否删除用户
        if (confirm(`确定要删除用户ID为${uid}，用户名为${uname}的用户吗？`)) {
            $.ajax({
                type: 'POST',
                url: 'http://127.0.0.1:8080/new/deleteUser',
                dataType: 'json',
                data: {uid: uid, uname: uname},
                success: function (data) {
                    if (data === 1) {
                        alert('用户删除成功！');
                        fetchUserStats();
                        closeDeleteModal(); // 关闭模态框
                    } else {
                        alert('用户删除失败，请检查用户ID和用户名是否正确！');
                    }
                },
                error: function () {
                    alert('无法与服务器连接，请检查网络或接口地址！');
                }
            });
        }
    }
}

// 假设 uroot 是一个已定义的变量
if (uroot != 8) {
    const element = document.getElementById("ftype");
    if (element) {
        element.style.display = "none";
    }
}

function back1() {
    window.location.href = 'main.html?uroot=' + encodeURIComponent(uroot) + "&uid=" + encodeURIComponent(id) + "&uname=" + encodeURIComponent(name)
}



